Spec (Assignment 2)

The deadline for this assignment is Friday the 4th of August, 11:59:59 PM.

Late submissions are accepted up to five days after the deadline, but at a penalty: 5% off your total mark per day. Submissions more than 5 days (120 hours) after the deadline are not accepted.

We cannot issue individual deadline extensions unless:

• You have an ELP, or
• you apply for, and you're granted, special consideration.

While connected/using a CSE machine, type the following to submit your work from the directory within the assignment folder:

$ give cs3141 assignment2 QuizMarker.hs

Alternatively, you can use the give web interface.

Your submission should work on the ghc version on the CSE lab system, which is ghc 8.8.4. When you submit, some basic tests will be run. These tests are not sufficient, and you should additionally run your own tests.

Do not remove any of the declarations from the template, do not change their type, and do not move them into a local scope (such as a let or where block). We won't be able to test your submission if you do.

Note that you will submit only the Haskell module file called QuizMarker.hs (and not the entire project).

This assignment will ask you to implement your own version of the COMP3141 quiz marking script, which we implement in Haskell for dogfooding purposes.

This time, the business logic involved is fairly basic arithmetic, and the bulk of the work is parsing the file formats in which quiz answer keys and submissions are represented. Therefore, the bulk of the assignment involves writing a parser using a bespoke Parser monad.

A Parser, in the most general terms, will consume some input and attempt to produce some output.

A Parser a consumes input (of type String), and can either fail (represented by returning Nothing) or produce a value of type a along with a String of leftovers – this is the unconsumed suffix of the original input.

newtype Parser a = Parser (String -> Maybe (String,a))

The discerning reader will recognise that this looks somewhat like the State monad but hardcoded to state type String, and with an extra Maybe. The Maybe is important because parsers will not, in general, succeed for all possible inputs. This kind of monad is sometimes called a state and failure monad.

Monadic parsers give you a way of writing parsers for complex data formats, by composing them from simpler parsers using combinators. The most important combinator is >>=, which in the Parser monad gives you a way to sequentially compose two parsers as follows:

The parser p >>= k will first run the parser p. If p fails, the whole thing fails. Otherwise, k will be invoked with the value returned by p, and invoked on the rest of the input. For example, consider the following parser of type Parser Double:

parseDouble >>= \x ->
keyword "+" >>
parseDouble >>= \y ->
return(x+y)

…or equivalently in do notation:

do
  x <- parseDouble
  keyword "+"
  y <- parseDouble
  return(x+y)

This parser will attempt to read a number from the start of the input; call this number x. On the remaining input, it will then attempt to find the string + as the next symbol. After the +, the input will be scanned for a number; call this number y. If all of the above succeeds, the composite parser will succeed with the result x+y. Otherwise, the parser fails. For example, if the input is "1+2" we would expect to return 3.0.

This part of the assignment consists of the following subtasks:

1. Implement first :: [Parser a] -> Parser a (1 mark)
2. Implement peekChar :: Parser Char (0.5 marks)
3. Implement parseChar :: Parser Char (0.5 marks)
4. Implement whiteSpace :: Parser () (0.5 mark)
5. Implement parseBool :: Parser Bool (0.5 mark)
6. Implement parsePositiveInt :: Parser Int (1 marks)
7. Implement parseDouble :: Parser Double (1.5 marks)
8. Implement parseString :: Parser String (1.5 marks)
9. Implement parseList :: Char -> Char -> Parser a -> Parser [a] (2 marks)

More detailed instructions, including descriptions of what exactly these functions should do, can be found in the code template.

Quiz submissions are stored in a JSON format, and our next task is to use our parsing library to implement a JSON parser. Instead of parsing all the way to a domain-specific data format, we will target a Haskell representation of JSON syntax trees, as follows:

data JSON = JSON [(String,Data)] deriving (Eq,Show)

data Data =
  Number Double
  | String String
  | List [Data]
  | Bool Bool
  | Null
  | JSONData JSON deriving (Eq,Show)

Note the mutual recursion: a JSON object (represented by JSON) is a key-value store where values are of type Data, and Data items may themselves be JSON objects.

For our business logic, we don't particularly want to work directly with JSON objects, instead we'd like to work with Submission defined as follows:

data Submission =
  Submission { session :: String,
               quizName :: String,
               student :: String,
               answers :: [[Int]],
               time :: UTCTime
             } deriving (Eq,Show)

Thus our next task is to convert our parsed JSON objects into this format.

1. Implement toSubmission :: JSON -> Maybe Submission (2 marks)
2. Implement toSubmissions :: JSON -> Maybe [(String,Submission)] (1 mark)

These return Maybe values because it's possible to have valid JSON that nonetheless does not represent a valid submission. Therefore, you may find the Maybe monad helpful for implementing these functions.

As usual, more details can be found in the inline comments.

Quizzes are stored in a data format where the first line is the deadline, and the remaining lines are | separated tuples of question number, question type, and list of answers. For example, this is the answer key for quiz05

2023-07-13 23:59:59
1|checkbox|1, 2, 3, 4, 5, 7
2|checkbox|1
3|checkbox|1
4|radio|3
5|radio|3, 4
6|radio|3
7|radio|5
8|radio|5

We want to parse such files into the following data representation:

data QuestionType = Radio | CheckBox deriving (Eq,Show)

data Question =
  Question { number  :: Int,
             qtype   :: QuestionType,
             correct :: [Int]
           } deriving (Eq,Show)

data Quiz =
  Quiz { deadline :: UTCTime,
         questions :: [Question]
       } deriving (Eq,Show)

We now have all the parsers we need, and all that remains is business logic and pretty-printing.

Quizzes are marked according to the following logic:

• A late submission is worth 0 marks
• Single-choice question are worth 1 mark if the student provided exactly one answer, which was correct, and 0 otherwise.
• Multiple-choice question are worth \(\mathit{max}(0,(r-w)/c)\), where \(r\) is the number of correct answers given by the student, \(w\) is is the number of incorrect answers given by the student, and \(c\) is the number of correct answers in the answer sheet.

The results should be presented in the upd file format used by CSE's give system. Here's an example upd file:

z1234567|quiz01|3
z2345678|quiz01|7.45

Each line is a | separated tuple of student ID, quiz name and marks.